Hunter_Population_Manager Class Reference

The class to handle all predator population related matters. More...

#include <Hunters_all.h>

Inheritance diagram for Hunter_Population_Manager:

Public Member Functions
	Hunter_Population_Manager (Landscape *p_L)
	Hunter population manager constructor. More...
virtual	~Hunter_Population_Manager (void)
	Hunter population manager destructor. More...
void	Init (void)
	Create the initial hunter population and initializes any output options. More...
void	DistributeHunters (void)
	Distributes hunters to hunting locations (farms). More...
void	DistributeHuntersByRules (vector< HunterInfo > *a_hunterlist, int a_no_hunters, int a_ruleset)
	Implements the rule sets to distributes hunters to hunting locations (farms). More...
void	RuleSet10Based (int a_no_hunters, vector< int > *a_farmsizes, vector< HunterInfo > *a_hunterlist, vector< APoint > *a_roostlocs, int a_ruleset)
	Used to implement rule sets based on rule set 10. More...
void	SaveDistributedHunters (vector< HunterInfo > *a_hunterlist, int a_no_hunters)
	Saves the results of the hunter distribution to an output file. More...
void	SaveFarmHunters (vector< HunterInfo > *a_hunterlist, int a_no_hunters)
	Saves the results of the hunter distribution to an output file by farm. More...
void	CreateObjects (int ob_type, TAnimal *, struct_Hunter *data, int number)
	Creates hunter objects and assigns them to the population manager lists. More...
void	RecordHuntingSuccess (int poly, int birds, int a_hunter)
	Hunting bag output. More...
APoint	GetHunterHome (int a_index, int a_list)
	Returns the hunter home location. More...
APoint	GetHunterHuntLoc (int a_index, int a_list, unsigned a_ref)
	Returns the hunter hunting location location. More...
unsigned	GetNoHuntLocs ()
	Calculates the number of hunting locations based on a distribution. More...
bool	CheckDensity (int a_ref, vector< int > *a_illegalfarms, vector< FarmOccupcancyData > *a_FarmOccupancy)
	helper method to reduce code size in hunter rules - checks density rules More...
bool	AddHunterHunting (int a_polyref, Hunter *a_hunter)
	Adds a hunter hunting, returns true if that hunter is the leader otherwise false. More...
void	HunterLeaderMessage (TypeOfHunterLeaderMessage a_signal, int a_polyref)
	A message system to rely messages from the leader hunter to others in his team. More...
bool	IsPolyrefOnActiveList (int a_polyref)
	Debugging check method. More...
void	SetHuntingSeason ()
	This returns the number of geese which are legal quarry on the polygon the day before. More...
int	GetHuntingSeasonStart ()
	Get the start of the overall hunting season. More...
int	GetHuntingSeasonEnd ()
	Get the end of the overall hunting season. More...
Public Member Functions inherited from Population_Manager
	Population_Manager (Landscape *L)
virtual	~Population_Manager (void)
void	SetNoProbes (int a_pn)
unsigned	GetLiveArraySize (int a_listindex)
	Gets the number of 'live' objects for a list index in the TheArray. More...
void	IncLiveArraySize (int a_listindex)
	Increments the number of 'live' objects for a list index in the TheArray. More...
virtual void	Catastrophe (int)
unsigned int	FarmAnimalCensus (unsigned int a_farm, unsigned int a_typeofanimal)
char *	SpeciesSpecificReporting (int a_species, int a_time)
char *	ProbeReport (int a_time)
char *	ProbeReportTimed (int a_time)
void	ImpactProbeReport (int a_Time)
bool	BeginningOfMonth ()
void	LOG (const char *fname)
int	SupplyStepSize ()
int	SupplySimW ()
int	SupplySimH ()
virtual void	Run (int NoTSteps)
virtual float	Probe (int ListIndex, probe_data *p_TheProbe)
virtual void	ImpactedProbe ()
int	SupplyListNameLength ()
TAnimal *	SupplyAnimalPtr (int a_index, int a_animal)
	Returns the pointer indexed by a_index and a_animal. Note NO RANGE CHECK. More...
unsigned	SupplyListIndexSize ()
unsigned	SupplyListSize (unsigned listindex)
bool	CheckXY (int l, int i)
	Debug method to test for out of bounds coordinates. More...
const char *	SupplyListName (int i)
bool	IsLast (unsigned listindex)
int	SupplyState (unsigned listindex, unsigned j)
virtual void	SupplyLocXY (unsigned listindex, unsigned j, int &x, int &y)
const char *	SupplyStateNames (int i)
unsigned	SupplyStateNamesLength ()
virtual void	DisplayLocations ()
int	ProbeFileInput (char *p_Filename, int p_ProbeNo)
TAnimal *	FindClosest (int x, int y, unsigned Type)
bool	OpenTheRipleysOutputProbe (string a_NWordFilename)
void	OpenTheAOROutputProbe (string a_AORFilename)
bool	OpenTheMonthlyRipleysOutputProbe ()
bool	OpenTheReallyBigProbe ()
virtual void	TheAOROutputProbe ()
virtual void	TheRipleysOutputProbe (FILE *a_prb)
virtual void	TheReallyBigOutputProbe ()
void	CloseTheMonthlyRipleysOutputProbe ()
virtual void	CloseTheRipleysOutputProbe ()
virtual void	CloseTheReallyBigOutputProbe ()
TTypesOfPopulation	GetPopulationType ()
int	GetSeasonNumber ()
	Get the season number. More...
void	LamdaDeath (int x, int y)
void	LamdaBirth (int x, int y)
void	LamdaBirth (int x, int y, int z)
void	LamdaClear ()
void	LamdaDumpOutput ()
virtual int	SupplyPegPosx (int)
virtual int	SupplyPegPosy (int)
virtual int	SupplyCovPosx (int)
virtual int	SupplyCovPosy (int)
virtual bool	OpenTheFledgelingProbe ()
virtual bool	OpenTheBreedingPairsProbe ()
virtual bool	OpenTheBreedingSuccessProbe ()
virtual void	BreedingPairsOutput (int)
virtual int	TheBreedingFemalesProbe (int)
virtual int	TheFledgelingProbe ()
virtual void	BreedingSuccessProbeOutput (double, int, int, int, int, int, int, int)
virtual int	TheBreedingSuccessProbe (int &, int &, int &, int &, int &, int &)
virtual void	FledgelingProbeOutput (int, int)
virtual void	TheGeneticProbe (unsigned, int, unsigned &)
virtual void	GeneticsResultsOutput (FILE *, unsigned)

Public Attributes
vector< HunterList * >	m_ActiveHuntingLocationsHunters
	Lists of hunters at all active hunting locations (updated daily) More...
vector< int >	m_ActiveHuntingLocationsPolyrefs
	Lists of polygon reference numbers for all active hunting locations (updated daily) More...
Public Attributes inherited from Population_Manager
int	IndexArrayX [5][10000]
probe_data *	TheProbe [100]
int	SimH
int	SimW
unsigned	SimHH
unsigned	SimWH
char	m_SimulationName [255]
bool	ProbesSet
Landscape *	m_TheLandscape

Protected Member Functions
virtual bool	StepFinished ()
	Overrides the population manager StepFinished - there is no chance that hunters do not finish a step behaviour. More...
virtual void	DoFirst ()
	Does general daily tasks e.g. reset time of day, reset bag lists if start of year etc.. More...
virtual void	DoBefore ()
	Available for hunter management - not used currently. More...
virtual void	DoAfter ()
	Available for hunter management - not used currently. More...
virtual void	DoLast ()
	Available for hunter management - not used currently. More...
Protected Member Functions inherited from Population_Manager
virtual void	DoAlmostLast ()
void	EmptyTheArray ()
	Removes all objects from the TheArray by deleting them and clearing TheArray. More...
void	SortX (unsigned Type)
void	SortXIndex (unsigned Type)
void	SortY (unsigned Type)
void	SortState (unsigned Type)
void	SortStateR (unsigned Type)
unsigned	PartitionLiveDead (unsigned Type)
void	Shuffle_or_Sort (unsigned Type)
void	Shuffle (unsigned Type)
virtual void	Catastrophe ()

Protected Attributes
unsigned	m_daytime
	Used to follow the time of day in 10 minute steps. More...
ofstream *	m_HuntingBagRecord
	Output file for hunting bag record. More...
int	m_HuntingSeasonStart
	Start of the overall hunting season. More...
int	m_HuntingSeasonEnd
	End of the overall hunting season. More...
Protected Attributes inherited from Population_Manager
vector< unsigned >	m_LiveArraySize
int	m_NoProbes
AOR_Probe *	m_AOR_Probe
FILE *	m_GeneticsFile
FILE *	m_AlleleFreqsFile
FILE *	m_EasyPopRes
const char *	StateNames [100]
int	m_catastrophestartyear
int	m_StepSize
vector< TListOfAnimals >	TheArray
unsigned	StateNamesLength
const char *	m_ListNames [32]
unsigned	m_ListNameLength
FILE *	TestFile
FILE *	TestFile2
unsigned	BeforeStepActions [12]
int	m_SeasonNumber
	Holds the season number. Used when running goose and hunter sims. More...
TTypesOfPopulation	m_population_type
ofstream *	AOROutputPrb
FILE *	RipleysOutputPrb
FILE *	RipleysOutputPrb1
FILE *	RipleysOutputPrb2
FILE *	RipleysOutputPrb3
FILE *	RipleysOutputPrb4
FILE *	RipleysOutputPrb5
FILE *	RipleysOutputPrb6
FILE *	RipleysOutputPrb7
FILE *	RipleysOutputPrb8
FILE *	RipleysOutputPrb9
FILE *	RipleysOutputPrb10
FILE *	RipleysOutputPrb11
FILE *	RipleysOutputPrb12
FILE *	ReallyBigOutputPrb
long int	lamdagrid [2][257][257]

Detailed Description

The class to handle all predator population related matters.

Constructor & Destructor Documentation

Hunter_Population_Manager()

Hunter_Population_Manager::Hunter_Population_Manager

(

Landscape *

p_L

)

Hunter population manager constructor.

There are two possibilities here - we can be in simulation mode or distribution mode. Simulation mode calls Init and runs hunters as normal whereas distribution mode will attempt to distribute hunters to hunting locations based on model rules. This is also needed for the first time simulations are run to distribute the hunters and produce input for Hunter_Initiation.txt

                                                                   : Population_Manager(p_L)
{
    // Load List of Animal Classes
    m_ListNames[0] = "Goose Hunter";
    m_ListNameLength = 1;
    // We need one vector for each life stage
    for (unsigned i=0; i<(10-m_ListNameLength); i++)
    {
        TheArray.pop_back();
    }
    BeforeStepActions[ 0 ] = 4; // 0 = Shuffle, 1 = SortX, 2 = SortY, 3=SortXIndex, 4 = do nothing, 5 = shuffle 1 in 500 times
    if (!cfg_Hunters_Distribute.value()) Init(); else DistributeHunters();
    m_HuntingSeasonStart = -1;
    m_HuntingSeasonEnd = -1;
    SetHuntingSeason();
}

References Population_Manager::BeforeStepActions, cfg_Hunters_Distribute, DistributeHunters(), Init(), m_HuntingSeasonEnd, m_HuntingSeasonStart, Population_Manager::m_ListNameLength, Population_Manager::m_ListNames, SetHuntingSeason(), Population_Manager::TheArray, and CfgBool::value().

~Hunter_Population_Manager()

Hunter_Population_Manager::~Hunter_Population_Manager ( void  )

virtual

Hunter population manager destructor.

{
    // close down output
    if (cfg_Hunters_RecordBag.value())
    {
        m_HuntingBagRecord->close();
        delete m_HuntingBagRecord;
    }
}

References cfg_Hunters_RecordBag, m_HuntingBagRecord, and CfgBool::value().

Member Function Documentation

AddHunterHunting()

bool Hunter_Population_Manager::AddHunterHunting	(	int	a_polyref,
		Hunter *	a_hunter
	)

Adds a hunter hunting, returns true if that hunter is the leader otherwise false.

The field that a hunter is hunting is referenced by a_polyref. First we need to check whether this location already exists. NB this list is emptied every day, so only contains locations where hunters have been or are allocated today.

If the location is found, then the hunter is not a leader and we need to tell them that (returns false)

If the polyref does not already exist the location was not found, it must be new, so we need to add it to the list and tell the hunter he is a leader

                                                                                  {
    for (unsigned i = 0; i < m_ActiveHuntingLocationsPolyrefs.size(); i++) {
        if (m_ActiveHuntingLocationsPolyrefs[ i ] == a_polyref) {
            m_ActiveHuntingLocationsHunters[ i ]->push_back( a_hunter );
            return false;
        }
    }
    HunterList* p_newhunterlist = new HunterList;
    p_newhunterlist->push_back( a_hunter );
    m_ActiveHuntingLocationsHunters.push_back( p_newhunterlist );
    m_ActiveHuntingLocationsPolyrefs.push_back( a_polyref );
    return true;
}

References m_ActiveHuntingLocationsHunters, and m_ActiveHuntingLocationsPolyrefs.

Referenced by GooseHunter::st_OutHunting().

CheckDensity()

bool Hunter_Population_Manager::CheckDensity	(	int	a_ref,
		vector< int > *	a_illegalfarms,
		vector< FarmOccupcancyData > *	a_FarmOccupancy
	)

helper method to reduce code size in hunter rules - checks density rules

Parameters

[in]	a_ref	The farm reference number
[in]	a_illegalfarms	The list of farms with densities exceeding the limit set for this run
[in]	a_FarmOccupancy	The list of farms that are occupied and the number of hunters allocated to them

Returns

bool true if the hunter could be allocated, false if not

Area is in m2, so divide by 10000. Hunter density in hunters/ha

Loop through all the farms that are already occupied and figure out if we have this one already

{
    FarmManager* FManager = m_TheLandscape->SupplyFarmManagerPtr();
    //double area = m_TheLandscape->SupplyFarmManagerPtr()->GetFarmTotalSize( a_ref ) / 10000.0;
    double area = m_TheLandscape->SupplyFarmManagerPtr()->GetFarmAreaOpenFields( a_ref, (int)cfg_goose_MinForageOpenness.value()) / 10000.0;
    for (int f = 0; f < a_FarmOccupancy->size(); f++) {
        // test if we have this one
        if ((*a_FarmOccupancy)[f].m_FarmRef == a_ref) {
            double newhunters = (*a_FarmOccupancy)[f].m_no_hunters + 1.0;
            if ( (newhunters/ area) < cfg_Hunters_MaxDensity.value()) {
                (*a_FarmOccupancy)[f].m_no_hunters++; // Add ourselves
                return true; // The farm was OK
            }
            else {
                FManager->AddToIllegalList(a_ref, a_illegalfarms);
                return false;
            }
        }
    }
    // If we reach here it must be a new farm
    // New farm, so is it big enough for one hunter?
    if (1.0 / area > cfg_Hunters_MaxDensity.value())
    {
        // Need to add to the illegal list
        FManager->AddToIllegalList(a_ref, a_illegalfarms);
        return false;
    }
    else {
        FarmOccupcancyData pt;
        pt.m_FarmRef = a_ref;
        pt.m_no_hunters = 1;
        a_FarmOccupancy->push_back(pt);
        return true;
    }
}

References FarmManager::AddToIllegalList(), cfg_goose_MinForageOpenness, cfg_Hunters_MaxDensity, FarmManager::GetFarmAreaOpenFields(), FarmOccupcancyData::m_FarmRef, FarmOccupcancyData::m_no_hunters, Population_Manager::m_TheLandscape, Landscape::SupplyFarmManagerPtr(), and CfgFloat::value().

Referenced by DistributeHuntersByRules(), and RuleSet10Based().

CreateObjects()

void Hunter_Population_Manager::CreateObjects	(	int	ob_type,
		TAnimal *	,
		struct_Hunter *	data,
		int	number
	)

Creates hunter objects and assigns them to the population manager lists.

{
    GooseHunter* GHunter = NULL;
    for (int i=0; i<a_number; i++)
    {
        switch (a_ob_type)
        {
        case toh_GooseHunter:
            if (g_PopulationManagerList.GetPopulation(TOP_Goose) == NULL) break; // Don't make goose hunters if we are not running geese
            GHunter = new GooseHunter(p_data, this);
            TheArray[a_ob_type].push_back(GHunter);
            break;
        default:
            char ob[ 255 ];
            sprintf( ob, "%d", (int) a_ob_type);
            m_TheLandscape->Warn("Goose_Population_Manager::CreateObjects() unknown object type - ", ob);
            exit(1);
            break;
        }
    }
}

References g_PopulationManagerList, PopulationManagerList::GetPopulation(), Population_Manager::m_TheLandscape, Population_Manager::TheArray, toh_GooseHunter, TOP_Goose, and Landscape::Warn().

Referenced by Init().

DistributeHunters()

void Hunter_Population_Manager::DistributeHunters

(

void

)

Distributes hunters to hunting locations (farms).

Reads in the hunter home data which consists of a hunter reference and home x,y coordinates only. Hunter type is by default 0 i.e. goose hunter (to be changed when we have more hunter base types)

We now need to add the number of hunting locations to each hunter. This is done by the method GetNoHuntLocs() which returns the number of locations. We use this to resize the storage for the number of locations.

{
//  FarmManager* FManager = m_TheLandscape->SupplyFarmManagerPtr();
    ifstream huntercoords("./HunterHomeLocations.txt", ios::in);
    if (!huntercoords.is_open()) {
        m_TheLandscape->Warn( "Hunter_Population_Manager::DistributeHunters()", "HunterHomeLocations.txt missing" );
        exit( 1 );
    }
    int no_hunters;
    huntercoords >> no_hunters;
    vector<HunterInfo>* OurHunters = new vector<HunterInfo>;
    OurHunters->resize( no_hunters );
    for (int i = 0; i < no_hunters; i++)
    {
        huntercoords >> (*OurHunters)[ i ].refID >> (*OurHunters)[ i ].homeX >> (*OurHunters)[ i ].homeY;
        (*OurHunters)[ i ].FarmHuntRef.resize( GetNoHuntLocs() );
        for (int hl = 0; hl<(*OurHunters)[i].FarmHuntRef.size(); hl++) (*OurHunters)[i].FarmHuntRef[hl] = -1;
        //(*OurHunters)[ i ].CheckedFarms.resize( FManager->GetNoFarms() );
    }
    huntercoords.close();
    // Do the distribution
    DistributeHuntersByRules(OurHunters, no_hunters, cfg_Hunters_Distribute_Ruleset.value());
    // Now save the results
    SaveDistributedHunters(OurHunters, no_hunters);
    SaveFarmHunters(OurHunters, no_hunters);
    g_msg->Warn("Normal exit after hunter distribution. No of records written to Hunter_Hunting_Locations.txt was: ", no_hunters);
    exit(0);
}

References cfg_Hunters_Distribute_Ruleset, DistributeHuntersByRules(), g_msg, GetNoHuntLocs(), Population_Manager::m_TheLandscape, SaveDistributedHunters(), SaveFarmHunters(), CfgInt::value(), MapErrorMsg::Warn(), and Landscape::Warn().

Referenced by Hunter_Population_Manager().

DistributeHuntersByRules()

void Hunter_Population_Manager::DistributeHuntersByRules	(	vector< HunterInfo > *	a_hunterlist,
		int	a_no_hunters,
		int	a_ruleset
	)

Implements the rule sets to distributes hunters to hunting locations (farms).

To distribute the hunters to farms we need the farm information. This resides in the FarmManager held by the landscape, so first we need a pointer to that. The Farm Manager has handy routines for use with the farm allocations .

We need to be able to do the following:

• Pick a random farm (set 0)
• Pick the closest farm (set 1)
• Pick a random farm with openness above x (set 2)
• Pick a random farm but upto a maximum density of hunters (set 3)
• The closest farm with openness above x (set 4)
• Pick the closest farm but upto a max hunter density (set 5)
• Pick a random farm with openness above x but upto a max hunter density (set 6)
• Pick the closest farm with openness above and upto a maximum density of hunters (set 7)

Rule set 0 is simply random distribution to any farm

Rule set 1 - the closest farm

Rule set 2 - Random with openness above cfg_GooseMinForageOpenness

Rule set 3 - random subject to hunter density restrictions

Rule set 4 - openness above cfg_GooseMinForageOpenness but closest to home

Rule set 5 - Pick the closest farm but upto a max hunter density

Rule set 6 - Pick a random farm with openness above and upto a maximum density of hunters

Rule set 7 - Pick the closest farm with openness above and upto a maximum density of hunters

Rule set 8 - the closest farm but based on probability. Requires a probability function which is a power curve using one parameter.

Rule set 9 - the closest farm with openness above X, but based on probability for closeness. Requires a probability function which is a power curve using one parameter.

Rule set 10 - the closest farm with openness above X, on probability for closeness and on density. Requires a probability function which is a power curve using one parameter.

Rule set 11 - the closest farm with openness above X, on probability for closeness and on a probability of the acceptance being reduced with farm size. Requires a probability function which is a power curve using one parameter for distance and a second for area.

Rule set 12 - the closest farm with openness above X, on probability for closeness and on a probability of the acceptance being reduced with distance from roost. Requires a probability function which is a power curve using one parameter for distance and a second for roost distance.

{
    FarmManager* FManager = m_TheLandscape->SupplyFarmManagerPtr();
    // Now we distribute the hunters to farms depending on which rule set we are using
 
 
    FManager->CalcCentroids(); // Makes sure that farm centres are calculated
    if (a_ruleset == 0)
    {
        for (int i = 0; i < a_no_hunters; i++)
        {
            // It is certain that some will be allocated to the same farm twice or more at some point, so we need to stop this. 
            for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
            {
                int theref = -1;
                do {
                    // The line below actuall does the interesting bit
                    theref = FManager->GetRandomFarmRefnum();
                } while (FManager->IsDuplicateRef(theref, &(*a_hunterlist)[i]));
                (*a_hunterlist)[i].FarmHuntRef[h] = theref;
            }
        }
    }
    else if (a_ruleset == 1)
    {
        vector<int>* list = new vector<int>;
        list->resize(1);
        (*list)[0] = 0;
        for (int i = 0; i < a_no_hunters; i++)
        {
            // It is certain that some will be allocated to the same farm twice or more at some point, so we need to stop this. 
            for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
            {
                // The line below actuall does the interesting bit
                (*a_hunterlist)[i].FarmHuntRef[h] = FManager->FindClosestFarm((*a_hunterlist)[i], &list[0]);
            }
        }
    }
    else if (a_ruleset == 2)
    {
        for (int i = 0; i < a_no_hunters; i++)
        {
            // It is certain that some will be allocated to the same farm twice or more at some point, so we need to stop this. 
            for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
            {
                int theref = -1;
                do {
                    // The line below actually does the interesting bit
                    theref = FManager->FindOpennessFarm((int)cfg_goose_MinForageOpenness.value());
                } while (FManager->IsDuplicateRef(theref, &(*a_hunterlist)[i]));
                (*a_hunterlist)[i].FarmHuntRef[h] = theref;
            }
        }
    }
    else if (a_ruleset == 3)
    {
        vector<int>* illegalfarms = new vector<int>;
        vector<FarmOccupcancyData>* FarmOccupancy = new vector<FarmOccupcancyData>;
        for (int i = 0; i < a_no_hunters; i++)
        {
            for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
            {
                bool found1 = false;
                int theref = -1;
                // While a farm is not allocated
                int iteration = 0;
                while (!found1) {
                    if (++iteration > FManager->GetNoFarms())
                    {
                        g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                        exit(0);
                    }
                    // Choose a new farm ref to test
                    theref = FManager->FindFarmWithRandom(illegalfarms);
                    found1 = CheckDensity(theref, illegalfarms, FarmOccupancy);
 
                }
                (*a_hunterlist)[i].FarmHuntRef[h] = theref;
#ifdef __DEBUG_DENSITY
                double areaHa = FManager->GetFarmTotalSize(theref) / 10000.0;
                double nohunters = 0;
                for (int g = 0; g < a_no_hunters; g++)
                {
 
                    for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
                    {
                        if ((*a_hunterlist)[g].FarmHuntRef[hs] == theref) nohunters++;
                    }
                }
                if (nohunters / areaHa > cfg_Hunters_MaxDensity.value())
                {
                    g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                    exit(0);
                }
                for (int frm = 0; frm < FarmOccupancy->size(); frm++)
                {
 
                    nohunters = 0;
                    for (int g = 0; g < a_no_hunters; g++)
                    {
 
                        for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
                        {
                            if ((*a_hunterlist)[g].FarmHuntRef[hs] == (*FarmOccupancy)[frm].m_FarmRef) nohunters++;
                        }
                    }
                    if ((*FarmOccupancy)[frm].m_no_hunters != nohunters)
                    {
                        g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                        exit(0);
                    }
                }
#endif              
 
            }
        }
    }
    else if (a_ruleset == 4)
    {
        vector<int>* list = new vector<int>;
        list->resize(1);
        (*list)[0] = 0;
        for (int i = 0; i < a_no_hunters; i++)
        {
            for (int f = 0; f < int((*a_hunterlist)[i].FarmHuntRef.size()); f++)
            {
                (*a_hunterlist)[i].FarmHuntRef[f] = FManager->FindClosestFarmOpenness((*a_hunterlist)[i], list, (int)cfg_goose_MinForageOpenness.value());
            }
        }
    }
    else if (a_ruleset == 5) {
        // First calculate the hunter densities
        // This depends on the way we want to do this, one way is total farm area, the other is open farm area.
        // Both ways are listed here.
        vector<int>* illegalfarms = new vector<int>;
        vector<FarmOccupcancyData>* FarmOccupancy = new vector<FarmOccupcancyData>;
        // When we enter this no hunters will be allocated, so we need to keep a list uptodate as we go along
        // For each hunter
        for (int i = 0; i < a_no_hunters; i++) {
            for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
            {
                bool found1 = false;
                // While a farm is not allocated
                int iteration = 0;
                int theref = -1;
                while (!found1)
                {
                    if (++iteration > FManager->GetNoFarms())
                    {
                        g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                        exit(0);
                    }
                    // Choose a new farm ref to test
                    theref = FManager->FindClosestFarm((*a_hunterlist)[i], illegalfarms);
                    found1 = CheckDensity(theref, illegalfarms, FarmOccupancy);
                }
                (*a_hunterlist)[i].FarmHuntRef[h] = theref;
#ifdef __DEBUG_DENSITY
                double areaHa = FManager->GetFarmTotalSize(theref) / 10000.0;
                double nohunters = 0;
                for (int g = 0; g < a_no_hunters; g++)
                {
 
                    for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
                    {
                        if ((*a_hunterlist)[g].FarmHuntRef[hs] == theref) nohunters++;
                    }
                }
                if (nohunters / areaHa > cfg_Hunters_MaxDensity.value())
                {
                    g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                    exit(0);
                }
                for (int frm = 0; frm < FarmOccupancy->size(); frm++)
                {
 
                    nohunters = 0;
                    for (int g = 0; g < a_no_hunters; g++)
                    {
 
                        for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
                        {
                            if ((*a_hunterlist)[g].FarmHuntRef[hs] == (*FarmOccupancy)[frm].m_FarmRef) nohunters++;
                        }
                    }
                    if ((*FarmOccupancy)[frm].m_no_hunters != nohunters)
                    {
                        g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                        exit(0);
                    }
                }
#endif              
            }
        }
    }
    else if (a_ruleset == 6) {
        vector<int>* illegalfarms = new vector<int>;
        vector<FarmOccupcancyData>* FarmOccupancy = new vector<FarmOccupcancyData>;
        int TheOpenness = (int)cfg_goose_MinForageOpenness.value();
        // When we enter this no hunters will be allocated, so we need to keep a list uptodate as we go along
        // For each hunter
        for (int i = 0; i < a_no_hunters; i++) {
            for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++) {
                int Farms = FManager->GetNoFarms();
                bool found1 = false;
                int iteration = 0;
                int theref = -1;
                do {
                    if (++iteration > Farms) {
                        g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                        exit(0);
                    }
                    // Choose a new farm ref to test
                    do {
                        // The line below actually does the interesting bit
                        theref = FManager->FindFarmWithOpenness(illegalfarms, TheOpenness);
                        if (theref == -1) {
                            g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, in openness, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                            exit(0);
                        }
                        if (illegalfarms->size() >= Farms - ((*a_hunterlist)[ i ].FarmHuntRef.size())) {
                            g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, all farms illegal, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                            exit(0);
                        }
                    } while (FManager->IsDuplicateRef(theref, &(*a_hunterlist)[i]));
                    found1 = CheckDensity(theref, illegalfarms, FarmOccupancy);
                } while (!found1);
                (*a_hunterlist)[i].FarmHuntRef[h] = theref;
#ifdef __DEBUG_DENSITY
                double areaHa = FManager->GetFarmTotalSize(theref) / 10000.0;
                double nohunters = 0;
                for (int g = 0; g < a_no_hunters; g++)
                {
 
                    for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
                    {
                        if ((*a_hunterlist)[g].FarmHuntRef[hs] == theref) nohunters++;
                    }
                }
                if (nohunters / areaHa > cfg_Hunters_MaxDensity.value())
                {
                    g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                    exit(0);
                }
                for (int frm = 0; frm < FarmOccupancy->size(); frm++)
                {
 
                    nohunters = 0;
                    for (int g = 0; g < a_no_hunters; g++)
                    {
 
                        for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
                        {
                            if ((*a_hunterlist)[g].FarmHuntRef[hs] == (*FarmOccupancy)[frm].m_FarmRef) nohunters++;
                        }
                    }
                    if ((*FarmOccupancy)[frm].m_no_hunters != nohunters)
                    {
                        g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                        exit(0);
                    }
                }
#endif              
            }
        }
        delete illegalfarms;
    }
    else if (a_ruleset == 7) {
        // First calculate the hunter densities
        // This depends on the way we want to do this, one way is total farm area, the other is open farm area.
        // Both ways are listed here.
        vector<int>* illegalfarms = new vector<int>;
        vector<FarmOccupcancyData>* FarmOccupancy = new vector<FarmOccupcancyData>;
        // When we enter this no hunters will be allocated, so we need to keep a list uptodate as we go along
        // For each hunter
        for (int i = 0; i < a_no_hunters; i++)
        {
            for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++)
            {
                bool found1 = false;
                int theref = -1;
                // While a farm is not allocated
                int iteration = 0;
                while (!found1)
                {
                    if (++iteration > FManager->GetNoFarms())
                    {
                        g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                        exit(0);
                    }
                    // Choose a new farm ref to test
                    theref = FManager->FindClosestFarmOpenness((*a_hunterlist)[i], illegalfarms, (int)cfg_goose_MinForageOpenness.value());
                    found1 = CheckDensity(theref, illegalfarms, FarmOccupancy);
                }
                (*a_hunterlist)[i].FarmHuntRef[h] = theref;
#ifdef __DEBUG_DENSITY
                double areaHa = FManager->GetFarmTotalSize(theref) / 10000.0;
                double nohunters = 0;
                for (int g = 0; g < a_no_hunters; g++)
                {
 
                    for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
                    {
                        if ((*a_hunterlist)[g].FarmHuntRef[hs] == theref) nohunters++;
                    }
                }
                if (nohunters / areaHa > cfg_Hunters_MaxDensity.value())
                {
                    g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                    exit(0);
                }
                for (int frm = 0; frm < FarmOccupancy->size(); frm++)
                {
 
                    nohunters = 0;
                    for (int g = 0; g < a_no_hunters; g++)
                    {
 
                        for (int hs = 0; hs < int((*a_hunterlist)[g].FarmHuntRef.size()); hs++)
                        {
                            if ((*a_hunterlist)[g].FarmHuntRef[hs] == (*FarmOccupancy)[frm].m_FarmRef) nohunters++;
                        }
                    }
                    if ((*FarmOccupancy)[frm].m_no_hunters != nohunters)
                    {
                        g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - debug density error, rule set ", cfg_Hunters_Distribute_Ruleset.value());
                        exit(0);
                    }
                }
#endif
            }
        }
    }
    else if (a_ruleset == 8) {
        vector<int>* list = new vector<int>;
        list->resize(1);
        (*list)[0] = 0;
        for (int i = 0; i < a_no_hunters; i++) {
            for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++) {
                (*a_hunterlist)[i].FarmHuntRef[h] = FManager->FindClosestFarmOpennessProb((*a_hunterlist)[i], &list[0], -1); // -1 means no openness will be used
            }
        }
    }
    else if (a_ruleset == 9) {
        vector<int>* list = new vector<int>;
        list->resize(1);
        (*list)[0] = 0;
        for (int i = 0; i < a_no_hunters; i++) {
            for (int h = 0; h < int((*a_hunterlist)[i].FarmHuntRef.size()); h++) {
                (*a_hunterlist)[i].FarmHuntRef[h] = FManager->FindClosestFarmOpennessProb((*a_hunterlist)[i], &list[0], (int)cfg_goose_MinForageOpenness.value());
            }
        }
    }
    else if (a_ruleset == 10) {
        RuleSet10Based( a_no_hunters, NULL, a_hunterlist, NULL, 10 );
    }
    else if (a_ruleset == 11) {
        // Need to read in the areas real areas for the farms
        vector<int>* farmsizes = new vector<int>;
        //read the input file
        ifstream ifile( "FarmTotalSizeData.txt", ios::in );
        //check if there is an input file
        if (!ifile.is_open()) {
            cout << "Cannot open input file " << "FarmTotalSizeData.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immediately
            exit( 1 );
        }
        //get the number of farms
        int noFarms;
        ifile >> noFarms; // Could do a check here that this is the right number of farms
        if (noFarms != m_TheLandscape->SupplyNumberOfFarms()) {
            cout << "Number of farms does not match farm number in ALMaSS " << noFarms << " != " << m_TheLandscape->SupplyNumberOfFarms() << endl;
            char ch;
            cin >> ch; //so that it doesn't close immediately
            exit( 1 );
        }
        //read the data and assign values to the farm's variables
        for (int f = 0; f < noFarms; f++) {
            int data;
            ifile >> data; // this is the farm number
            ifile >> data;
            farmsizes->push_back( data );
        }
        ifile.close();
        // OK farm size data read in, lets continue
        RuleSet10Based( a_no_hunters, farmsizes, a_hunterlist, NULL, 11 );
        delete farmsizes;
    }
    else if (a_ruleset == 12) {
        // Need to read in the areas real areas for the farms
        vector<APoint>* roostlocs = new vector<APoint>;
        //read the input file
        ifstream ifile( "GooseRoosts.txt", ios::in );
        //check if there is an input file
        if (!ifile.is_open()) {
            cout << "Cannot open input file " << "GooseRoosts.txt" << endl;
            char ch;
            cin >> ch; //so that it doesn't close immediately
            exit( 1 );
        }
        //get the number of farms
        int noroosts;
        ifile >> noroosts; // Could do a check here that this is the right number of farms
        //read the data and assign values to the roost locs
        for (int r = 0; r < noroosts; r++) {
            APoint data; 
            int species;
            ifile >> species >> data.m_x >> data.m_y;
            roostlocs->push_back( data );
        }
        ifile.close();
        // OK farm size data read in, lets continue
        RuleSet10Based( a_no_hunters, NULL, a_hunterlist, roostlocs, 12 );
        delete roostlocs;
    }
    else {
        g_msg->Warn("Hunter_Population_Manager::DistributeHunters() - Unknown hunter distribution rule set", cfg_Hunters_Distribute_Ruleset.value());
        exit(0);
    }
}

References FarmManager::CalcCentroids(), cfg_goose_MinForageOpenness, cfg_Hunters_Distribute_Ruleset, cfg_Hunters_MaxDensity, CheckDensity(), FarmManager::FindClosestFarm(), FarmManager::FindClosestFarmOpenness(), FarmManager::FindClosestFarmOpennessProb(), FarmManager::FindFarmWithOpenness(), FarmManager::FindFarmWithRandom(), FarmManager::FindOpennessFarm(), g_msg, FarmManager::GetFarmTotalSize(), FarmManager::GetNoFarms(), FarmManager::GetRandomFarmRefnum(), FarmManager::IsDuplicateRef(), Population_Manager::m_TheLandscape, APoint::m_x, APoint::m_y, RuleSet10Based(), Landscape::SupplyFarmManagerPtr(), Landscape::SupplyNumberOfFarms(), CfgInt::value(), CfgFloat::value(), and MapErrorMsg::Warn().

Referenced by DistributeHunters().

DoAfter()

virtual void Hunter_Population_Manager::DoAfter ( )

inlineprotectedvirtual

Available for hunter management - not used currently.

Reimplemented from Population_Manager.

{}

DoBefore()

virtual void Hunter_Population_Manager::DoBefore ( void  )

inlineprotectedvirtual

Available for hunter management - not used currently.

Reimplemented from Population_Manager.

{}

DoFirst()

void Hunter_Population_Manager::DoFirst ( void  )

protectedvirtual

Does general daily tasks e.g. reset time of day, reset bag lists if start of year etc..

Reimplemented from Population_Manager.

{
    int today = m_TheLandscape->SupplyDayInYear();
    if (m_daytime == 0)
    {
        // Start of day so do some housekeeping.
        // Reset all clocks
        for (unsigned i=0; i<m_ListNameLength; i++)
        {
            int sz = (int) TheArray[i].size();
            for (int j=0; j<sz; j++)
            {
                GooseHunter* h = (GooseHunter*) TheArray[i][j];
                h->ResetClock();
                h->OnMorning();
                if (h->IsOutHunting()) {
                    g_msg->Warn("Hunter_Population_Manager::DoFirst() - hunter out hunting at midnight at ref ", h->GetHuntField());
                    g_msg->Warn("Hunter_Population_Manager::DoFirst() - hunter clock is  ", h->GetClock());
                    g_msg->Warn("Hunter_Population_Manager::DoFirst() - hunter is leader ", h->IsLeader());
                    g_msg->Warn("Day in year is: ", m_TheLandscape->SupplyDayInYear());
                    g_msg->Warn("Year is: ", m_TheLandscape->SupplyYearNumber());
                    exit(0);
                }
            }
        }
        // Clear all active hunting location information
        for (unsigned i = 0; i < m_ActiveHuntingLocationsPolyrefs.size(); i++) {
            delete m_ActiveHuntingLocationsHunters[ i ];
        }
        m_ActiveHuntingLocationsHunters.clear();
        m_ActiveHuntingLocationsPolyrefs.clear();
        // If end of season, reset bags etc. 
        // Here we only need to ask the first hunter in each list, the answer is the same for the rest 
        for (unsigned i = 0; i < m_ListNameLength; i++) {
            if ((int)TheArray[ i ].size() > 0) {
                Hunter* h = (Hunter*)TheArray[ i ][ 0 ];
                if (h->IsSeasonEnd( today ) && m_SeasonNumber > 0) {
                    ofstream ofile( "HuntingOpportunities.txt", ios::app | ios::out);
                    int year = m_TheLandscape->SupplyYearNumber()-1; // This makes it zero based and cuts out the hidden year. 
                    int sz = (int)TheArray[ i ].size();
                    for (int j = 0; j < sz; j++) {
                        h = (Hunter*)TheArray[ i ][ j ];
                        ofile << year << '\t';
                        h->SaveMyData( &ofile );
                        h->ResetSeasonData();
                    }
                    ofile.close();
                }
            }
        }
    }
    m_daytime = ( m_daytime + 10 ) % 1440; // We have 10 minutes timesteps
    if (today == 183 && m_daytime == 1430) m_SeasonNumber++;
}

References g_msg, Hunter::GetClock(), Hunter::GetHuntField(), GooseHunter::IsLeader(), Hunter::IsOutHunting(), Hunter::IsSeasonEnd(), m_ActiveHuntingLocationsHunters, m_ActiveHuntingLocationsPolyrefs, m_daytime, Population_Manager::m_ListNameLength, Population_Manager::m_SeasonNumber, Population_Manager::m_TheLandscape, Hunter::OnMorning(), Hunter::ResetClock(), Hunter::ResetSeasonData(), Hunter::SaveMyData(), Landscape::SupplyDayInYear(), Landscape::SupplyYearNumber(), Population_Manager::TheArray, and MapErrorMsg::Warn().

DoLast()

virtual void Hunter_Population_Manager::DoLast ( void  )

inlineprotectedvirtual

Available for hunter management - not used currently.

Reimplemented from Population_Manager.

{}

GetHunterHome()

APoint Hunter_Population_Manager::GetHunterHome	(	int	a_index,
		int	a_list
	)

Returns the hunter home location.

{
    return dynamic_cast<Hunter*>(TheArray[a_list][a_index])->GetHome();
}

References Population_Manager::TheArray.

GetHunterHuntLoc()

APoint Hunter_Population_Manager::GetHunterHuntLoc	(	int	a_index,
		int	a_list,
		unsigned	a_ref
	)

Returns the hunter hunting location location.

{
    return dynamic_cast<Hunter*>(TheArray[a_list][a_index])->GetHuntLoc(a_ref);
}

References Population_Manager::TheArray.

GetHuntingSeasonEnd()

int Hunter_Population_Manager::GetHuntingSeasonEnd ( )

inline

Get the end of the overall hunting season.

{ return m_HuntingSeasonEnd; }

References m_HuntingSeasonEnd.

Referenced by GooseHunter::GetSeasonLengthLeft(), GooseHunter::InSeason(), and GooseHunter::IsSeasonEnd().

GetHuntingSeasonStart()

int Hunter_Population_Manager::GetHuntingSeasonStart ( )

inline

Get the start of the overall hunting season.

{ return m_HuntingSeasonStart; }

References m_HuntingSeasonStart.

Referenced by GooseHunter::GetSeasonLengthLeft(), and GooseHunter::InSeason().

GetNoHuntLocs()

unsigned Hunter_Population_Manager::GetNoHuntLocs

(

)

Calculates the number of hunting locations based on a distribution.

Calculates the number of hunting locations based on a distribution. Uses probability of one location, two locations or three+

{
    double chance = g_rand_uni();
    if (chance < cfg_hunterlocONE.value())   return 1;
    if (chance < cfg_hunterlocTWO.value())   return 2;
    if (chance < cfg_hunterlocTHREE.value()) return 3;
    if (chance < cfg_hunterlocFOUR.value())  return 4;
    return 5;
 
}

References cfg_hunterlocFOUR, cfg_hunterlocONE, cfg_hunterlocTHREE, cfg_hunterlocTWO, g_rand_uni, and CfgFloat::value().

Referenced by DistributeHunters().

HunterLeaderMessage()

void Hunter_Population_Manager::HunterLeaderMessage	(	TypeOfHunterLeaderMessage	a_signal,
		int	a_polyref
	)

A message system to rely messages from the leader hunter to others in his team.

This is used to relay a message from a leader hunter to any other hunters in a field at the same time as the leader. The leader passes the polygon reference number which is used to find the list of hunters. They are then each called passing them an event specified by a_signal (currently there is only two types of message, but this can be expanded).

{
    for (unsigned i = 0; i < m_ActiveHuntingLocationsPolyrefs.size(); i++) {
        if (a_polyref == m_ActiveHuntingLocationsPolyrefs[i])
        {
            for (int h = 1; h < m_ActiveHuntingLocationsHunters[i]->size(); h++)
            {
                switch (a_signal)
                {
                case hlm_shoot:
                    (*m_ActiveHuntingLocationsHunters[i])[h]->OnShoot();
                    break;
                case hlm_gohome:
                    (*m_ActiveHuntingLocationsHunters[i])[h]->OnGoHome();
                    break;
                default:
                    g_msg->Warn("Hunter_Population_Manager::HunterLeaderMessage unknown leader message: ", a_signal);
                    exit(0);
                }
            }
            return;
        }
    }
    g_msg->Warn("Hunter_Population_Manager::HunterLeaderMessage polyref does not match any of the active polygons in list: ", a_polyref);
    exit(0);
}

References g_msg, hlm_gohome, hlm_shoot, m_ActiveHuntingLocationsHunters, m_ActiveHuntingLocationsPolyrefs, and MapErrorMsg::Warn().

Referenced by GooseHunter::st_OutHunting().

Init()

void Hunter_Population_Manager::Init

(

void

)

Create the initial hunter population and initializes any output options.

Here we need to create the initial hunter population with each individual with its own hunting pattern in terms of timing, location, and intensity/efficiency. Information on hunters is specified in the Hunter_Hunting_Locations.txt file.

One of the challenges is to ensure that we have a matching prey population for each hunter. This is achieved by two structures, the first being a variable in each Population_Manager that states its type (m_population_type) and its associated enum TTypesOfPopulation. The second is a globally visible structure holding a list of any active population managers.

This method also initializes any output options.

{
    int no_hunters;
    struct_Hunter sh;
    sh.m_L = m_TheLandscape;
    ifstream    hunterinifile("./Hunter_Hunting_Locations.txt", ios::in);
    if (!hunterinifile.is_open()) {
        m_TheLandscape->Warn( "Hunter_Population_Manager::Init", "Hunter_Hunting_Locations.txt missing" );
        exit( 1 );
    }
    hunterinifile >> no_hunters;
    // Now we skip the header line:
    string line;
    for (int i = 0; i < 19; i++) hunterinifile >> line;
    if (line != "FarmRef10") {
        m_TheLandscape->Warn( "Hunter_Population_Manager::Init", "Header line missing from Hunter_Hunting_Locations.txt" );
        exit( 1 );
    }
    /*
    * Reads the hunter data line by hunter line.\n
    * Each hunter entry is of the following format:\n
    * - Hunter type (0 = Goose Hunter) (int) 
    * - x/y home location (int) 
    * - Hunting day limit, ie how many days the hunter will go out (int) 
    * - Active hunting days of the week, 1 = everyday, 0 weekends only (int) 
    * - Efficiency (% hits) when geese are present (double) 
    * - Daily chance of checking for geese (prob 0.0-1.0) (double) 
    * - Number of hunting locations (int)
    * - Farm reference numbers where they hunt (up to 10).
    *
    */
    for (int h = 0; h < no_hunters; h++)
    {
        int no_huntlocs;
        hunterinifile >> sh.m_ref >> sh.m_HType >> sh.m_huntingdayslimit >> sh.m_weekend >> sh.m_goosecountchance >> sh.m_efficiency >> sh.m_home.m_x >> sh.m_home.m_y >> no_huntlocs;
        // resize our vectors
        // TODO one day - create another struct to make this a single vector - just to make the code a little more tidy
        sh.m_farms.resize(no_huntlocs);
        sh.m_huntlocrefs.resize(no_huntlocs);
        sh.m_huntlocs.resize(no_huntlocs);
        for (int i = 0; i < no_huntlocs; i++)
        {
            hunterinifile >> sh.m_huntlocrefs[i];
            APoint fp = m_TheLandscape->SupplyFarmManagerPtr()->GetFarmCentroid( sh.m_huntlocrefs[ i ] );
            sh.m_huntlocs[ i ].m_x = fp.m_x;
            sh.m_huntlocs[ i ].m_y = fp.m_y;
            // Need to get the farm* from farmref
            sh.m_farms[i] = m_TheLandscape->SupplyFarmManagerPtr()->GetFarmPtr(sh.m_huntlocrefs[i]);
        }
        for (int i = 0; i < 10-no_huntlocs; i++) 
        {
            hunterinifile >> line; // Skip the NA's
        }
        if (sh.m_HType == toh_GooseHunter) sh.m_preyPM = g_PopulationManagerList.GetPopulation(TOP_Goose);
        else
        {
            g_msg->Warn("Hunter_Population_Manager::Init unknown hunter type: ", sh.m_HType);
            exit(0);
        }
        CreateObjects( sh.m_HType, NULL, &sh, 1 );
    }
    hunterinifile.close();
        
    m_daytime = 0; // Make sure we start the simulation at dawn (as the geese do).
    // Initialise output
    if (cfg_Hunters_RecordBag.value())
    {
        m_HuntingBagRecord = new ofstream("HuntingBagRecord.txt", ios::out);
        (*m_HuntingBagRecord) << "Year" << '\t' << "Day" << '\t' << "Hour" << '\t' << "Minute" << '\t' << "Season" << '\t' <<
            "HunterRef" << '\t' << "PolygonRef" << '\t' << "x-coord" << '\t' << "y-coord" << '\t' << "GameType" << endl;
    }
    ofstream ofile("HuntingOpportunities.txt", ios::out);
    ofile << "Year" << '\t' << "HunterRef" << '\t' << "HuntingDays" << '\t' << "TotalBag" << '\t' << "NumberOfShots" << '\t' <<
        "GameType0" << '\t' << "GameType1" << '\t' << "GameType2" << '\t' << "GameType3" << '\t' << "GameType4" << '\t' << "GameType5" << endl;
    ofile.close();
}

References cfg_Hunters_RecordBag, CreateObjects(), g_msg, g_PopulationManagerList, FarmManager::GetFarmCentroid(), FarmManager::GetFarmPtr(), PopulationManagerList::GetPopulation(), m_daytime, struct_Hunter::m_efficiency, struct_Hunter::m_farms, struct_Hunter::m_goosecountchance, struct_Hunter::m_home, struct_Hunter::m_HType, m_HuntingBagRecord, struct_Hunter::m_huntingdayslimit, struct_Hunter::m_huntlocrefs, struct_Hunter::m_huntlocs, struct_Hunter::m_L, struct_Hunter::m_preyPM, struct_Hunter::m_ref, Population_Manager::m_TheLandscape, struct_Hunter::m_weekend, APoint::m_x, APoint::m_y, Landscape::SupplyFarmManagerPtr(), toh_GooseHunter, TOP_Goose, CfgBool::value(), MapErrorMsg::Warn(), and Landscape::Warn().

Referenced by Hunter_Population_Manager().

IsPolyrefOnActiveList()

bool Hunter_Population_Manager::IsPolyrefOnActiveList

(

int

a_polyref

)

Debugging check method.

{
    bool found = false;
    for (unsigned i = 0; i < m_ActiveHuntingLocationsPolyrefs.size(); i++) {
        if (a_polyref == m_ActiveHuntingLocationsPolyrefs[ i ]) {
            found = true;
            break;
        }
    }
    return found;
}

References m_ActiveHuntingLocationsPolyrefs.

RecordHuntingSuccess()

void Hunter_Population_Manager::RecordHuntingSuccess	(	int	poly,
		int	birds,
		int	a_hunter
	)

Hunting bag output.

This method stores information about the birds that have been shot. It is essential that the hunting bag record file is open when this is called - there is no checking. This is controlled by a configuration variable cfg_Hunters_RecordBag

{
    APoint pt = m_TheLandscape->SupplyCentroid(a_poly);
    (*m_HuntingBagRecord) << m_TheLandscape->SupplyYear() << '\t' << m_TheLandscape->SupplyDayInYear() << '\t' << g_date->GetHour() << '\t' <<
        g_date->GetMinute() << '\t' << GetSeasonNumber() << '\t' << a_hunter << '\t' << a_poly << '\t' << pt.m_x << '\t' << pt.m_y << '\t' << a_birds << endl;
 
    
}

References g_date, Calendar::GetHour(), Calendar::GetMinute(), Population_Manager::GetSeasonNumber(), Population_Manager::m_TheLandscape, APoint::m_x, APoint::m_y, Landscape::SupplyCentroid(), Landscape::SupplyDayInYear(), and Landscape::SupplyYear().

Referenced by GooseHunter::OnShotABird().

RuleSet10Based()

void Hunter_Population_Manager::RuleSet10Based	(	int	a_no_hunters,
		vector< int > *	a_farmsizes,
		vector< HunterInfo > *	a_hunterlist,
		vector< APoint > *	a_roostlocs,
		int	a_ruleset
	)

Used to implement rule sets based on rule set 10.

                                                                                                                                                                         {
    FarmManager* FManager = m_TheLandscape->SupplyFarmManagerPtr();
    vector<int>* illegalfarms = new vector<int>;
    vector<FarmOccupcancyData>* FarmOccupancy = new vector<FarmOccupcancyData>;
    for (int i = 0; i < a_no_hunters; i++) {
        for (int h = 0; h < int( (*a_hunterlist)[ i ].FarmHuntRef.size() ); h++) {
            bool found1 = false;
            int theref = -1;
            // While a farm is not allocated
            int iteration = 0;
            while (!found1) {
                if (++iteration > FManager->GetNoFarms()) {
                    g_msg->Warn( "Hunter_Population_Manager::DistributeHunters() - unable to allocate hunter, rule set ", cfg_Hunters_Distribute_Ruleset.value() );
                    exit( 0 );
                }
                // Choose a new farm ref to test
                if (a_ruleset == 10) {
                    theref = FManager->FindClosestFarmOpennessProb( (*a_hunterlist)[ i ], illegalfarms, (int)cfg_goose_MinForageOpenness.value() );
                    found1 = CheckDensity( theref, illegalfarms, FarmOccupancy );
                }
                else if (a_ruleset == 11) {
                    // Choose a new farm ref to test
                    theref = FManager->FindClosestFarmOpennessProbSmallIsBest( (*a_hunterlist)[ i ], illegalfarms, (int)cfg_goose_MinForageOpenness.value(), a_farmsizes );
                    found1 = CheckDensity( theref, illegalfarms, FarmOccupancy );
                }
                else if (a_ruleset == 12) {
                    // Choose a new farm ref to test
                    theref = FManager->FindClosestFarmOpennessProbNearRoostIsBest( (*a_hunterlist)[ i ], illegalfarms, (int)cfg_goose_MinForageOpenness.value(), a_roostlocs );
                    found1 = CheckDensity( theref, illegalfarms, FarmOccupancy );
                }
            }
            (*a_hunterlist)[ i ].FarmHuntRef[ h ] = theref;
        }
    }
    delete illegalfarms;
}

References cfg_goose_MinForageOpenness, cfg_Hunters_Distribute_Ruleset, CheckDensity(), FarmManager::FindClosestFarmOpennessProb(), FarmManager::FindClosestFarmOpennessProbNearRoostIsBest(), FarmManager::FindClosestFarmOpennessProbSmallIsBest(), g_msg, FarmManager::GetNoFarms(), Population_Manager::m_TheLandscape, Landscape::SupplyFarmManagerPtr(), CfgInt::value(), CfgFloat::value(), and MapErrorMsg::Warn().

Referenced by DistributeHuntersByRules().

SaveDistributedHunters()

void Hunter_Population_Manager::SaveDistributedHunters	(	vector< HunterInfo > *	a_hunterlist,
		int	a_no_hunters
	)

Saves the results of the hunter distribution to an output file.

{
    ofstream huntlocs("./Hunter_Hunting_Locations.txt", ios::out);
    huntlocs << a_no_hunters << endl;
    huntlocs << "HunterID" << '\t' << "HunterType" << '\t' << "HuntingDays" << '\t' << "WeekdayHunterChance" << '\t' << "GooseLookChance" << '\t' << "Efficiency" << '\t';
    huntlocs << "HomeX" << '\t' << "HomeY" << '\t';
    huntlocs << "NoFarmrefs" << '\t' << "FarmRef1" << '\t' << "FarmRef2" << '\t' << "FarmRef3" << '\t' << "FarmRef4" << '\t' << "FarmRef5" << '\t' << "FarmRef6" << '\t' << "FarmRef7" << '\t' << "FarmRef8" << '\t' << "FarmRef9" << '\t' << "FarmRef10" << endl;
        
        //<< '\t' << "FarmCentroidX" << '\t' << "FarmCentroidY" << '\t' << "FarmTotalSize" << '\t' << "FarmArableSize" << '\t' << "FarmType" << '\t' << "NoFields" << '\t' << "NoOpenFields" << '\t' << "ValidFarmX" << '\t' << "ValidFarmY" << endl;
    /*FarmManager* FManager = m_TheLandscape->SupplyFarmManagerPtr();*/
    for (int i = 0; i < a_no_hunters; i++)
    {
        int nolocs = int((*a_hunterlist)[i].FarmHuntRef.size());
        huntlocs << (*a_hunterlist)[ i ].refID << '\t' << 0 << '\t' << 0 << '\t' << 0 << '\t' << 0 << '\t' << 0 << '\t';
        huntlocs << (*a_hunterlist)[ i ].homeX << '\t' << (*a_hunterlist)[ i ].homeY << '\t' << nolocs;
        for (int j = 0; j < nolocs; j++)
        {
            int ref = (*a_hunterlist)[ i ].FarmHuntRef[ j ];
            /* 
            APoint pt = FManager->GetFarmCentroid(ref);
            int FarmASize = FManager->GetFarmArableSize(ref);
            int FarmTSize = FManager->GetFarmTotalSize(ref);
            int FarmType = FManager->GetFarmType(ref);
            int OpenFields = FManager->GetFarmNoOpenFields(ref, (int)cfg_GooseMinForageOpenness.value());
            int NoFields = FManager->GetFarmNoFields(ref);
            APoint valid = FManager->GetFarmValidCoords(ref);*/
            huntlocs << '\t' << ref;
        }
        for (int j = 10; j > nolocs; j--) huntlocs << '\t' << "NA";
        huntlocs << endl;
    }
    huntlocs.close();
}

Referenced by DistributeHunters().

SaveFarmHunters()

void Hunter_Population_Manager::SaveFarmHunters	(	vector< HunterInfo > *	a_hunterlist,
		int	a_no_hunters
	)

Saves the results of the hunter distribution to an output file by farm.

                                                                                                    {
    FarmManager* FManager = m_TheLandscape->SupplyFarmManagerPtr();
    ofstream huntlocs("./Hunter_Hunting_Locations_Farms.txt", ios::out);
    huntlocs << "FarmRef" << '\t' << "FarmCentroidX" << '\t' << "FarmCentroidY" << '\t' << "FarmType" << '\t' << "FarmSize" << '\t'
        << "FarmArableSize" << '\t' << "NoFields" << '\t' << "NoOpenFields" << '\t' <<"AreaOpenFields" << '\t' << "NoHunters" << endl;
    vector<farminfo*> FarmList;
    for (int i = 0; i < a_no_hunters; i++)
    {
        for (int j = 0; j < (*a_hunterlist)[ i ].FarmHuntRef.size(); j++)
        {
            int ref = (*a_hunterlist)[ i ].FarmHuntRef[ j ];
            int found = -1;
            for (int f = 0; f < (int)FarmList.size(); f++) {
                if (FarmList[f]->m_farmref == ref) {
                    found = f;
                    break;
                }
            }
            if (found == -1) {
                farminfo* fi = new farminfo;
                fi->m_farmcentroid = FManager->GetFarmCentroid( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
                fi->m_farmvalid = FManager->GetFarmValidCoords( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
                fi->m_farmarable = FManager->GetFarmArableSize( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
                fi->m_farmsize = FManager->GetFarmTotalSize( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
                fi->m_farmtype = FManager->GetFarmType( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
                fi->m_openfields = FManager->GetFarmNoOpenFields( (*a_hunterlist)[ i ].FarmHuntRef[ j ], (int)cfg_goose_MinForageOpenness.value() );
                fi->m_areaopenfields = FManager->GetFarmAreaOpenFields( (*a_hunterlist)[ i ].FarmHuntRef[ j ], (int)cfg_goose_MinForageOpenness.value() );
                fi->m_nofields = FManager->GetFarmNoFields( (*a_hunterlist)[ i ].FarmHuntRef[ j ] );
                fi->m_farmref = (*a_hunterlist)[ i ].FarmHuntRef[ j ];
                fi->m_NoHunters = 1;
                FarmList.push_back(fi);
            }
            else FarmList[found]->m_NoHunters++;
        }
    }
    // Now we don't want any gaps so check all farms and then check them against our list of hunted farms
    int nofarms = FManager->GetNoFarms();
    for (int fa = 0; fa < nofarms; fa++) {
        int found = -1;
        Farm* farmp = FManager->GetFarmPtrIndex(fa);
        int ref = farmp->GetFarmNumber();
        cout << ref << '\t';
        for (int hf = 0; hf < FarmList.size( ); hf++) 
        {
            if (FarmList[hf]->m_farmref == ref) {
                found = hf;
                cout << ref << '\t' << found << endl;
                break;
            }
        }
        if (found == -1) {
            APoint pt = FManager->GetFarmCentroid( ref );
            huntlocs << ref << '\t' << pt.m_x << '\t' << pt.m_y << '\t' << FManager->GetFarmType(ref) << '\t' << FManager->GetFarmTotalSize(ref) << '\t'
                << FManager->GetFarmArableSize(ref) << '\t' << FManager->GetFarmNoFields(ref) << '\t' 
                << FManager->GetFarmNoOpenFields(ref, (int)cfg_goose_MinForageOpenness.value()) << '\t' << FManager->GetFarmAreaOpenFields(ref, (int)cfg_goose_MinForageOpenness.value()) << '\t' << 0 << endl;
        }
        else {
            huntlocs << ref << '\t' << FarmList[found]->m_farmcentroid.m_x << '\t' << FarmList[found]->m_farmcentroid.m_y << '\t' << FarmList[found]->m_farmtype << '\t' << FarmList[found]->m_farmsize << '\t'
                << FarmList[found]->m_farmarable << '\t' << FarmList[found]->m_nofields << '\t' << FarmList[found]->m_openfields << '\t' << FarmList[found]->m_areaopenfields << '\t' << FarmList[found]->m_NoHunters << endl;
        }
 
    }
    huntlocs.close();
}

References cfg_goose_MinForageOpenness, FarmManager::GetFarmArableSize(), FarmManager::GetFarmAreaOpenFields(), FarmManager::GetFarmCentroid(), FarmManager::GetFarmNoFields(), FarmManager::GetFarmNoOpenFields(), Farm::GetFarmNumber(), FarmManager::GetFarmPtrIndex(), FarmManager::GetFarmTotalSize(), FarmManager::GetFarmType(), FarmManager::GetFarmValidCoords(), FarmManager::GetNoFarms(), farminfo::m_areaopenfields, farminfo::m_farmarable, farminfo::m_farmcentroid, farminfo::m_farmref, farminfo::m_farmsize, farminfo::m_farmtype, farminfo::m_farmvalid, farminfo::m_nofields, farminfo::m_NoHunters, farminfo::m_openfields, Population_Manager::m_TheLandscape, APoint::m_x, APoint::m_y, Landscape::SupplyFarmManagerPtr(), and CfgFloat::value().

Referenced by DistributeHunters().

SetHuntingSeason()

void Hunter_Population_Manager::SetHuntingSeason

(

)

This returns the number of geese which are legal quarry on the polygon the day before.

The goose hunting season is complicated because it runs over a year boundary (or it can)

                                                 {
    int start1 = cfg_goose_pinkfootopenseasonstart.value();
    int end1 = cfg_goose_pinkfootopenseasonend.value();
    int start2 = cfg_goose_greylagopenseasonstart.value();
    int end2 = cfg_goose_greylagopenseasonend.value();
    /*Both start and end in the same year*/
    if (end1 > start1 && end2 > start2) {
        m_HuntingSeasonEnd = end1;
        if (m_HuntingSeasonEnd < end2)
        {
            m_HuntingSeasonEnd = end2;
        }
    }
    /*1 end in the second year*/
    if (start1 > end1 && start2 < end2)
    {
        m_HuntingSeasonEnd = end1;
    }
    /*2 end in the second year*/
    if (start1 < end1 && start2 > end2)
    {
        m_HuntingSeasonEnd = end2;
    }
    /*Both end in the second year*/
    if (start1 > end1 && start2 > end2)
    {
        m_HuntingSeasonEnd = end1;
        if (m_HuntingSeasonEnd < end2)
        {
            m_HuntingSeasonEnd = end2;
        }
    }
    if (start1 > start2)
    {
        m_HuntingSeasonStart = start2;
    }
    else m_HuntingSeasonStart = start1;
    if (m_HuntingSeasonStart < 0)
    {
        g_msg->Warn("Goose_Population_Manager::SetHuntingSeason() Start of hunting season:", m_HuntingSeasonStart);
        exit(1);
    }
    if (m_HuntingSeasonEnd < 0)
    {
        g_msg->Warn("Goose_Population_Manager::SetHuntingSeason() End of hunting season:", m_HuntingSeasonEnd);
        exit(1);
    }
}

References cfg_goose_greylagopenseasonend, cfg_goose_greylagopenseasonstart, cfg_goose_pinkfootopenseasonend, cfg_goose_pinkfootopenseasonstart, g_msg, m_HuntingSeasonEnd, m_HuntingSeasonStart, CfgInt::value(), and MapErrorMsg::Warn().

Referenced by Hunter_Population_Manager().

StepFinished()

virtual bool Hunter_Population_Manager::StepFinished ( void  )

inlineprotectedvirtual

Overrides the population manager StepFinished - there is no chance that hunters do not finish a step behaviour.

Returns true if and only if all objects have finished the current step

Reimplemented from Population_Manager.

{ return true; }

Member Data Documentation

m_ActiveHuntingLocationsHunters

vector<HunterList*> Hunter_Population_Manager::m_ActiveHuntingLocationsHunters

Lists of hunters at all active hunting locations (updated daily)

Referenced by AddHunterHunting(), DoFirst(), and HunterLeaderMessage().

m_ActiveHuntingLocationsPolyrefs

vector<int> Hunter_Population_Manager::m_ActiveHuntingLocationsPolyrefs

Lists of polygon reference numbers for all active hunting locations (updated daily)

Referenced by AddHunterHunting(), DoFirst(), HunterLeaderMessage(), and IsPolyrefOnActiveList().

m_daytime

unsigned Hunter_Population_Manager::m_daytime

protected

Used to follow the time of day in 10 minute steps.

Referenced by DoFirst(), and Init().

m_HuntingBagRecord

ofstream* Hunter_Population_Manager::m_HuntingBagRecord

protected

Output file for hunting bag record.

Referenced by Init(), and ~Hunter_Population_Manager().

m_HuntingSeasonEnd

int Hunter_Population_Manager::m_HuntingSeasonEnd

protected

End of the overall hunting season.

Referenced by GetHuntingSeasonEnd(), Hunter_Population_Manager(), and SetHuntingSeason().

m_HuntingSeasonStart

int Hunter_Population_Manager::m_HuntingSeasonStart

protected

Start of the overall hunting season.

Referenced by GetHuntingSeasonStart(), Hunter_Population_Manager(), and SetHuntingSeason().

---

The documentation for this class was generated from the following files:

• /builds/a1mass/almass_stable_oddox/Hunters/Hunters_all.h
• /builds/a1mass/almass_stable_oddox/Hunters/Hunters_all.cpp